/***
 * ASM: a very small and fast Java bytecode manipulation framework
 * Copyright (c) 2000-2005 INRIA, France Telecom
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of the copyright holders nor the names of its
 *    contributors may be used to endorse or promote products derived from
 *    this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */
package clojure.asm;

/**
 * A label represents a position in the bytecode of a method. Labels are used
 * for jump, goto, and switch instructions, and for try catch blocks.
 *
 * @author Eric Bruneton
 */
public class Label{

/**
 * Indicates if this label is only used for debug attributes. Such a label
 * is not the start of a basic block, the target of a jump instruction, or
 * an exception handler. It can be safely ignored in control flow graph
 * analysis algorithms (for optimization purposes).
 */
final static int DEBUG = 1;

/**
 * Indicates if the position of this label is known.
 */
final static int RESOLVED = 2;

/**
 * Indicates if this label has been updated, after instruction resizing.
 */
final static int RESIZED = 4;

/**
 * Indicates if this basic block has been pushed in the basic block stack.
 * See {@link MethodWriter#visitMaxs visitMaxs}.
 */
final static int PUSHED = 8;

/**
 * Indicates if this label is the target of a jump instruction, or the start
 * of an exception handler.
 */
final static int TARGET = 16;

/**
 * Indicates if a stack map frame must be stored for this label.
 */
final static int STORE = 32;

/**
 * Indicates if this label corresponds to a reachable basic block.
 */
final static int REACHABLE = 64;

/**
 * Indicates if this basic block ends with a JSR instruction.
 */
final static int JSR = 128;

/**
 * Indicates if this basic block ends with a RET instruction.
 */
final static int RET = 256;

/**
 * Field used to associate user information to a label.
 */
public Object info;

/**
 * Flags that indicate the status of this label.
 *
 * @see #DEBUG
 * @see #RESOLVED
 * @see #RESIZED
 * @see #PUSHED
 * @see #TARGET
 * @see #STORE
 * @see #REACHABLE
 * @see #JSR
 * @see #RET
 */
int status;

/**
 * The line number corresponding to this label, if known.
 */
int line;

/**
 * The position of this label in the code, if known.
 */
int position;

/**
 * Number of forward references to this label, times two.
 */
private int referenceCount;

/**
 * Informations about forward references. Each forward reference is
 * described by two consecutive integers in this array: the first one is the
 * position of the first byte of the bytecode instruction that contains the
 * forward reference, while the second is the position of the first byte of
 * the forward reference itself. In fact the sign of the first integer
 * indicates if this reference uses 2 or 4 bytes, and its absolute value
 * gives the position of the bytecode instruction.
 */
private int[] srcAndRefPositions;

// ------------------------------------------------------------------------

/*
	 * Fields for the control flow and data flow graph analysis algorithms (used
	 * to compute the maximum stack size or the stack map frames). A control
	 * flow graph contains one node per "basic block", and one edge per "jump"
	 * from one basic block to another. Each node (i.e., each basic block) is
	 * represented by the Label object that corresponds to the first instruction
	 * of this basic block. Each node also stores the list of its successors in
	 * the graph, as a linked list of Edge objects.
	 *
	 * The control flow analysis algorithms used to compute the maximum stack
	 * size or the stack map frames are similar and use two steps. The first
	 * step, during the visit of each instruction, builds information about the
	 * state of the local variables and the operand stack at the end of each
	 * basic block, called the "output frame", <i>relatively</i> to the frame
	 * state at the beginning of the basic block, which is called the "input
	 * frame", and which is <i>unknown</i> during this step. The second step,
	 * in {@link MethodWriter#visitMaxs}, is a fix point algorithm that
	 * computes information about the input frame of each basic block, from the
	 * input state of the first basic block (known from the method signature),
	 * and by the using the previously computed relative output frames.
	 *
	 * The algorithm used to compute the maximum stack size only computes the
	 * relative output and absolute input stack heights, while the algorithm
	 * used to compute stack map frames computes relative output frames and
	 * absolute input frames.
	 */

/**
 * Start of the output stack relatively to the input stack. The exact
 * semantics of this field depends on the algorithm that is used.
 * <p/>
 * When only the maximum stack size is computed, this field is the number of
 * elements in the input stack.
 * <p/>
 * When the stack map frames are completely computed, this field is the
 * offset of the first output stack element relatively to the top of the
 * input stack. This offset is always negative or null. A null offset means
 * that the output stack must be appended to the input stack. A -n offset
 * means that the first n output stack elements must replace the top n input
 * stack elements, and that the other elements must be appended to the input
 * stack.
 */
int inputStackTop;

/**
 * Maximum height reached by the output stack, relatively to the top of the
 * input stack. This maximum is always positive or null.
 */
int outputStackMax;

/**
 * Information about the input and output stack map frames of this basic
 * block. This field is only used when {@link ClassWriter#COMPUTE_FRAMES}
 * option is used.
 */
Frame frame;

/**
 * The successor of this label, in the order they are visited. This linked
 * list does not include labels used for debug info only. If
 * {@link ClassWriter#COMPUTE_FRAMES} option is used then, in addition, it
 * does not contain successive labels that denote the same bytecode position
 * (in this case only the first label appears in this list).
 */
Label successor;

/**
 * The successors of this node in the control flow graph. These successors
 * are stored in a linked list of {@link Edge Edge} objects, linked to each
 * other by their {@link Edge#next} field.
 */
Edge successors;

/**
 * The next basic block in the basic block stack. This stack is used in the
 * main loop of the fix point algorithm used in the second step of the
 * control flow analysis algorithms.
 *
 * @see MethodWriter#visitMaxs
 */
Label next;

// ------------------------------------------------------------------------
// Constructor
// ------------------------------------------------------------------------

/**
 * Constructs a new label.
 */
public Label(){
}

/**
 * Constructs a new label.
 *
 * @param debug if this label is only used for debug attributes.
 */
Label(final boolean debug){
	this.status = debug ? DEBUG : 0;
}

// ------------------------------------------------------------------------
// Methods to compute offsets and to manage forward references
// ------------------------------------------------------------------------

/**
 * Returns the offset corresponding to this label. This offset is computed
 * from the start of the method's bytecode. <i>This method is intended for
 * {@link Attribute} sub classes, and is normally not needed by class
 * generators or adapters.</i>
 *
 * @return the offset corresponding to this label.
 * @throws IllegalStateException if this label is not resolved yet.
 */
public int getOffset(){
	if((status & RESOLVED) == 0)
		{
		throw new IllegalStateException("Label offset position has not been resolved yet");
		}
	return position;
}

/**
 * Puts a reference to this label in the bytecode of a method. If the
 * position of the label is known, the offset is computed and written
 * directly. Otherwise, a null offset is written and a new forward reference
 * is declared for this label.
 *
 * @param owner      the code writer that calls this method.
 * @param out        the bytecode of the method.
 * @param source     the position of first byte of the bytecode instruction that
 *                   contains this label.
 * @param wideOffset <tt>true</tt> if the reference must be stored in 4
 *                   bytes, or <tt>false</tt> if it must be stored with 2 bytes.
 * @throws IllegalArgumentException if this label has not been created by
 *                                  the given code writer.
 */
void put(
		final MethodWriter owner,
		final ByteVector out,
		final int source,
		final boolean wideOffset){
	if((status & RESOLVED) != 0)
		{
		if(wideOffset)
			{
			out.putInt(position - source);
			}
		else
			{
			out.putShort(position - source);
			}
		}
	else
		{
		if(wideOffset)
			{
			addReference(-1 - source, out.length);
			out.putInt(-1);
			}
		else
			{
			addReference(source, out.length);
			out.putShort(-1);
			}
		}
}

/**
 * Adds a forward reference to this label. This method must be called only
 * for a true forward reference, i.e. only if this label is not resolved
 * yet. For backward references, the offset of the reference can be, and
 * must be, computed and stored directly.
 *
 * @param sourcePosition    the position of the referencing instruction. This
 *                          position will be used to compute the offset of this forward
 *                          reference.
 * @param referencePosition the position where the offset for this forward
 *                          reference must be stored.
 */
private void addReference(
		final int sourcePosition,
		final int referencePosition){
	if(srcAndRefPositions == null)
		{
		srcAndRefPositions = new int[6];
		}
	if(referenceCount >= srcAndRefPositions.length)
		{
		int[] a = new int[srcAndRefPositions.length + 6];
		System.arraycopy(srcAndRefPositions,
		                 0,
		                 a,
		                 0,
		                 srcAndRefPositions.length);
		srcAndRefPositions = a;
		}
	srcAndRefPositions[referenceCount++] = sourcePosition;
	srcAndRefPositions[referenceCount++] = referencePosition;
}

/**
 * Resolves all forward references to this label. This method must be called
 * when this label is added to the bytecode of the method, i.e. when its
 * position becomes known. This method fills in the blanks that where left
 * in the bytecode by each forward reference previously added to this label.
 *
 * @param owner    the code writer that calls this method.
 * @param position the position of this label in the bytecode.
 * @param data     the bytecode of the method.
 * @return <tt>true</tt> if a blank that was left for this label was to
 *         small to store the offset. In such a case the corresponding jump
 *         instruction is replaced with a pseudo instruction (using unused
 *         opcodes) using an unsigned two bytes offset. These pseudo
 *         instructions will need to be replaced with true instructions with
 *         wider offsets (4 bytes instead of 2). This is done in
 *         {@link MethodWriter#resizeInstructions}.
 * @throws IllegalArgumentException if this label has already been resolved,
 *                                  or if it has not been created by the given code writer.
 */
boolean resolve(
		final MethodWriter owner,
		final int position,
		final byte[] data){
	boolean needUpdate = false;
	this.status |= RESOLVED;
	this.position = position;
	int i = 0;
	while(i < referenceCount)
		{
		int source = srcAndRefPositions[i++];
		int reference = srcAndRefPositions[i++];
		int offset;
		if(source >= 0)
			{
			offset = position - source;
			if(offset < Short.MIN_VALUE || offset > Short.MAX_VALUE)
				{
				/*
									 * changes the opcode of the jump instruction, in order to
									 * be able to find it later (see resizeInstructions in
									 * MethodWriter). These temporary opcodes are similar to
									 * jump instruction opcodes, except that the 2 bytes offset
									 * is unsigned (and can therefore represent values from 0 to
									 * 65535, which is sufficient since the size of a method is
									 * limited to 65535 bytes).
									 */
				int opcode = data[reference - 1] & 0xFF;
				if(opcode <= Opcodes.JSR)
					{
					// changes IFEQ ... JSR to opcodes 202 to 217
					data[reference - 1] = (byte) (opcode + 49);
					}
				else
					{
					// changes IFNULL and IFNONNULL to opcodes 218 and 219
					data[reference - 1] = (byte) (opcode + 20);
					}
				needUpdate = true;
				}
			data[reference++] = (byte) (offset >>> 8);
			data[reference] = (byte) offset;
			}
		else
			{
			offset = position + source + 1;
			data[reference++] = (byte) (offset >>> 24);
			data[reference++] = (byte) (offset >>> 16);
			data[reference++] = (byte) (offset >>> 8);
			data[reference] = (byte) offset;
			}
		}
	return needUpdate;
}

/**
 * Returns the first label of the series to which this label belongs. For an
 * isolated label or for the first label in a series of successive labels,
 * this method returns the label itself. For other labels it returns the
 * first label of the series.
 *
 * @return the first label of the series to which this label belongs.
 */
Label getFirst(){
	return frame == null ? this : frame.owner;
}

// ------------------------------------------------------------------------
// Overriden Object methods
// ------------------------------------------------------------------------

/**
 * Returns a string representation of this label.
 *
 * @return a string representation of this label.
 */
public String toString(){
	return "L" + System.identityHashCode(this);
}
}
